package nav

/*
#include<stdint.h>
#include<stdbool.h>
extern int nav_dtAlign4(int x);
extern void nav_dtCalcPolyCenter(void * tc,void * idx,int nidx,void * verts);
extern bool nav_dtClosestHeightPointTriangle(void * tmp_arg_p,void * a,void * b,void * c,void * h);
extern void nav_dtClosestPtPointTriangle(void * closest,void * tmp_arg_p,void * a,void * b,void * c);
extern bool nav_dtDistancePtPolyEdgesSqr(void * pt,void * verts,int nverts,void * ed,void * et);
extern float nav_dtDistancePtSegSqr2D(void * pt,void * tmp_arg_p,void * q,void * t);
extern unsigned int nav_dtIlog2(unsigned int v);
extern bool nav_dtIntersectSegmentPoly2D(void * p0,void * p1,void * verts,int nverts,void * tmin,void * tmax,void * segMin,void * segMax);
extern bool nav_dtIntersectSegSeg2D(void * ap,void * aq,void * bp,void * bq,void * s,void * t);
extern unsigned int nav_dtNextPow2(unsigned int v);
extern int nav_dtOppositeTile(int side);
extern bool nav_dtOverlapBounds(void * amin,void * amax,void * bmin,void * bmax);
extern bool nav_dtOverlapPolyPoly2D(void * polya,int npolya,void * polyb,int npolyb);
extern bool nav_dtOverlapQuantBounds(void * amin,void * amax,void * bmin,void * bmax);
extern bool nav_dtPointInPolygon(void * pt,void * verts,int nverts);
extern void nav_dtRandomPointInConvexPoly(void * pts,int npts,void * areas,float s,float t,void * out);
extern void nav_dtSwapByte(void * a,void * b);
extern void nav_dtSwapEndian(void * v);
extern void nav_dtSwapEndian11(void * v);
extern void nav_dtSwapEndian12(void * v);
extern void nav_dtSwapEndian13(void * v);
extern void nav_dtSwapEndian14(void * v);
extern float nav_dtTriArea2D(void * a,void * b,void * c);
extern void nav_dtVadd(void * dest,void * v1,void * v2);
extern void nav_dtVcopy(void * dest,void * a);
extern void nav_dtVcross(void * dest,void * v1,void * v2);
extern float nav_dtVdist(void * v1,void * v2);
extern float nav_dtVdist2D(void * v1,void * v2);
extern float nav_dtVdist2DSqr(void * v1,void * v2);
extern float nav_dtVdistSqr(void * v1,void * v2);
extern float nav_dtVdot(void * v1,void * v2);
extern float nav_dtVdot2D(void * u,void * v);
extern bool nav_dtVequal(void * p0,void * p1);
extern bool nav_dtVisfinite(void * v);
extern bool nav_dtVisfinite2D(void * v);
extern float nav_dtVlen(void * v);
extern float nav_dtVlenSqr(void * v);
extern void nav_dtVlerp(void * dest,void * v1,void * v2,float t);
extern void nav_dtVmad(void * dest,void * v1,void * v2,float s);
extern void nav_dtVmax(void * mx,void * v);
extern void nav_dtVmin(void * mn,void * v);
extern void nav_dtVnormalize(void * v);
extern float nav_dtVperp2D(void * u,void * v);
extern void nav_dtVscale(void * dest,void * v,float t);
extern void nav_dtVset(void * dest,float x,float y,float z);
extern void nav_dtVsub(void * dest,void * v1,void * v2);

*/
import "C"
import "unsafe"
import "gitee.com/hasika/cgo"

var _ unsafe.Pointer
var _ cgo.NotUsed

/*
int dtAlign4(int x)
*/
func DtAlign4(x int32) int32 {
	var wrap_arg_x C.int
	wrap_arg_x = (C.int)(x)
	wrap_out := C.nav_dtAlign4(wrap_arg_x)
	go_out := int32(wrap_out)
	return go_out
}

/*
Derives the centroid of a convex polygon.

@param tc The centroid of the polgyon. [(x, y, z)]
@param idx The polygon indices. [(vertIndex) * @p nidx]
@param nidx The number of indices in the polygon. [Limit: >= 3]
@param verts The polygon vertices. [(x, y, z) * vertCount]

void dtCalcPolyCenter(float * tc, unsigned short const * idx, int nidx, float const * verts)
*/
func DtCalcPolyCenter(tc *float32, idx *uint16, nidx int32, verts *float32) {
	var wrap_arg_tc unsafe.Pointer
	var wrap_arg_idx unsafe.Pointer
	var wrap_arg_nidx C.int
	var wrap_arg_verts unsafe.Pointer
	wrap_arg_tc = (unsafe.Pointer)(tc)
	wrap_arg_idx = (unsafe.Pointer)(idx)
	wrap_arg_nidx = (C.int)(nidx)
	wrap_arg_verts = (unsafe.Pointer)(verts)
	C.nav_dtCalcPolyCenter(wrap_arg_tc, wrap_arg_idx, wrap_arg_nidx, wrap_arg_verts)
}

/*
Derives the y-axis height of the closest point on the triangle from the specified reference point.

@param p The reference point from which to test. [(x, y, z)]
@param a Vertex A of triangle ABC. [(x, y, z)]
@param b Vertex B of triangle ABC. [(x, y, z)]
@param c Vertex C of triangle ABC. [(x, y, z)]
@param h The resulting height.

bool dtClosestHeightPointTriangle(float const * tmp_arg_p, float const * a, float const * b, float const * c, float& h)
*/
func DtClosestHeightPointTriangle(tmp_arg_p *float32, a *float32, b *float32, c *float32, h *float32) bool {
	var wrap_arg_tmp_arg_p unsafe.Pointer
	var wrap_arg_a unsafe.Pointer
	var wrap_arg_b unsafe.Pointer
	var wrap_arg_c unsafe.Pointer
	var wrap_arg_h unsafe.Pointer
	wrap_arg_tmp_arg_p = (unsafe.Pointer)(tmp_arg_p)
	wrap_arg_a = (unsafe.Pointer)(a)
	wrap_arg_b = (unsafe.Pointer)(b)
	wrap_arg_c = (unsafe.Pointer)(c)
	wrap_arg_h = (unsafe.Pointer)(h)
	wrap_out := C.nav_dtClosestHeightPointTriangle(wrap_arg_tmp_arg_p, wrap_arg_a, wrap_arg_b, wrap_arg_c, wrap_arg_h)
	go_out := bool(wrap_out)
	return go_out
}

/*
Derives the closest point on a triangle from the specified reference point.

@param closest The closest point on the triangle.
@param p The reference point from which to test. [(x, y, z)]
@param a Vertex A of triangle ABC. [(x, y, z)]
@param b Vertex B of triangle ABC. [(x, y, z)]
@param c Vertex C of triangle ABC. [(x, y, z)]

void dtClosestPtPointTriangle(float * closest, float const * tmp_arg_p, float const * a, float const * b, float const * c)
*/
func DtClosestPtPointTriangle(closest *float32, tmp_arg_p *float32, a *float32, b *float32, c *float32) {
	var wrap_arg_closest unsafe.Pointer
	var wrap_arg_tmp_arg_p unsafe.Pointer
	var wrap_arg_a unsafe.Pointer
	var wrap_arg_b unsafe.Pointer
	var wrap_arg_c unsafe.Pointer
	wrap_arg_closest = (unsafe.Pointer)(closest)
	wrap_arg_tmp_arg_p = (unsafe.Pointer)(tmp_arg_p)
	wrap_arg_a = (unsafe.Pointer)(a)
	wrap_arg_b = (unsafe.Pointer)(b)
	wrap_arg_c = (unsafe.Pointer)(c)
	C.nav_dtClosestPtPointTriangle(wrap_arg_closest, wrap_arg_tmp_arg_p, wrap_arg_a, wrap_arg_b, wrap_arg_c)
}

/*
bool dtDistancePtPolyEdgesSqr(float const * pt, float const * verts, int const nverts, float * ed, float * et)
*/
func DtDistancePtPolyEdgesSqr(pt *float32, verts *float32, nverts int32, ed *float32, et *float32) bool {
	var wrap_arg_pt unsafe.Pointer
	var wrap_arg_verts unsafe.Pointer
	var wrap_arg_nverts C.int
	var wrap_arg_ed unsafe.Pointer
	var wrap_arg_et unsafe.Pointer
	wrap_arg_pt = (unsafe.Pointer)(pt)
	wrap_arg_verts = (unsafe.Pointer)(verts)
	wrap_arg_nverts = (C.int)(nverts)
	wrap_arg_ed = (unsafe.Pointer)(ed)
	wrap_arg_et = (unsafe.Pointer)(et)
	wrap_out := C.nav_dtDistancePtPolyEdgesSqr(wrap_arg_pt, wrap_arg_verts, wrap_arg_nverts, wrap_arg_ed, wrap_arg_et)
	go_out := bool(wrap_out)
	return go_out
}

/*
float dtDistancePtSegSqr2D(float const * pt, float const * tmp_arg_p, float const * q, float& t)
*/
func DtDistancePtSegSqr2D(pt *float32, tmp_arg_p *float32, q *float32, t *float32) float32 {
	var wrap_arg_pt unsafe.Pointer
	var wrap_arg_tmp_arg_p unsafe.Pointer
	var wrap_arg_q unsafe.Pointer
	var wrap_arg_t unsafe.Pointer
	wrap_arg_pt = (unsafe.Pointer)(pt)
	wrap_arg_tmp_arg_p = (unsafe.Pointer)(tmp_arg_p)
	wrap_arg_q = (unsafe.Pointer)(q)
	wrap_arg_t = (unsafe.Pointer)(t)
	wrap_out := C.nav_dtDistancePtSegSqr2D(wrap_arg_pt, wrap_arg_tmp_arg_p, wrap_arg_q, wrap_arg_t)
	go_out := float32(wrap_out)
	return go_out
}

/*
unsigned int dtIlog2(unsigned int v)
*/
func DtIlog2(v uint32) uint32 {
	var wrap_arg_v C.uint
	wrap_arg_v = (C.uint)(v)
	wrap_out := C.nav_dtIlog2(wrap_arg_v)
	go_out := uint32(wrap_out)
	return go_out
}

/*
bool dtIntersectSegmentPoly2D(float const * p0, float const * p1, float const * verts, int nverts, float& tmin, float& tmax, int& segMin, int& segMax)
*/
func DtIntersectSegmentPoly2D(p0 *float32, p1 *float32, verts *float32, nverts int32, tmin *float32, tmax *float32, segMin *int32, segMax *int32) bool {
	var wrap_arg_p0 unsafe.Pointer
	var wrap_arg_p1 unsafe.Pointer
	var wrap_arg_verts unsafe.Pointer
	var wrap_arg_nverts C.int
	var wrap_arg_tmin unsafe.Pointer
	var wrap_arg_tmax unsafe.Pointer
	var wrap_arg_segMin unsafe.Pointer
	var wrap_arg_segMax unsafe.Pointer
	wrap_arg_p0 = (unsafe.Pointer)(p0)
	wrap_arg_p1 = (unsafe.Pointer)(p1)
	wrap_arg_verts = (unsafe.Pointer)(verts)
	wrap_arg_nverts = (C.int)(nverts)
	wrap_arg_tmin = (unsafe.Pointer)(tmin)
	wrap_arg_tmax = (unsafe.Pointer)(tmax)
	wrap_arg_segMin = (unsafe.Pointer)(segMin)
	wrap_arg_segMax = (unsafe.Pointer)(segMax)
	wrap_out := C.nav_dtIntersectSegmentPoly2D(wrap_arg_p0, wrap_arg_p1, wrap_arg_verts, wrap_arg_nverts, wrap_arg_tmin, wrap_arg_tmax, wrap_arg_segMin, wrap_arg_segMax)
	go_out := bool(wrap_out)
	return go_out
}

/*
bool dtIntersectSegSeg2D(float const * ap, float const * aq, float const * bp, float const * bq, float& s, float& t)
*/
func DtIntersectSegSeg2D(ap *float32, aq *float32, bp *float32, bq *float32, s *float32, t *float32) bool {
	var wrap_arg_ap unsafe.Pointer
	var wrap_arg_aq unsafe.Pointer
	var wrap_arg_bp unsafe.Pointer
	var wrap_arg_bq unsafe.Pointer
	var wrap_arg_s unsafe.Pointer
	var wrap_arg_t unsafe.Pointer
	wrap_arg_ap = (unsafe.Pointer)(ap)
	wrap_arg_aq = (unsafe.Pointer)(aq)
	wrap_arg_bp = (unsafe.Pointer)(bp)
	wrap_arg_bq = (unsafe.Pointer)(bq)
	wrap_arg_s = (unsafe.Pointer)(s)
	wrap_arg_t = (unsafe.Pointer)(t)
	wrap_out := C.nav_dtIntersectSegSeg2D(wrap_arg_ap, wrap_arg_aq, wrap_arg_bp, wrap_arg_bq, wrap_arg_s, wrap_arg_t)
	go_out := bool(wrap_out)
	return go_out
}

/*
@
}

	Miscellanious functions.

@
{

unsigned int dtNextPow2(unsigned int v)
*/
func DtNextPow2(v uint32) uint32 {
	var wrap_arg_v C.uint
	wrap_arg_v = (C.uint)(v)
	wrap_out := C.nav_dtNextPow2(wrap_arg_v)
	go_out := uint32(wrap_out)
	return go_out
}

/*
int dtOppositeTile(int side)
*/
func DtOppositeTile(side int32) int32 {
	var wrap_arg_side C.int
	wrap_arg_side = (C.int)(side)
	wrap_out := C.nav_dtOppositeTile(wrap_arg_side)
	go_out := int32(wrap_out)
	return go_out
}

/*
Determines if two axis-aligned bounding boxes overlap.

@param amin Minimum bounds of box A. [(x, y, z)]
@param amax Maximum bounds of box A. [(x, y, z)]
@param bmin Minimum bounds of box B. [(x, y, z)]
@param bmax Maximum bounds of box B. [(x, y, z)]
@return True if the two AABB's overlap.
@see dtOverlapQuantBounds

bool dtOverlapBounds(float const * amin, float const * amax, float const * bmin, float const * bmax)
*/
func DtOverlapBounds(amin *float32, amax *float32, bmin *float32, bmax *float32) bool {
	var wrap_arg_amin unsafe.Pointer
	var wrap_arg_amax unsafe.Pointer
	var wrap_arg_bmin unsafe.Pointer
	var wrap_arg_bmax unsafe.Pointer
	wrap_arg_amin = (unsafe.Pointer)(amin)
	wrap_arg_amax = (unsafe.Pointer)(amax)
	wrap_arg_bmin = (unsafe.Pointer)(bmin)
	wrap_arg_bmax = (unsafe.Pointer)(bmax)
	wrap_out := C.nav_dtOverlapBounds(wrap_arg_amin, wrap_arg_amax, wrap_arg_bmin, wrap_arg_bmax)
	go_out := bool(wrap_out)
	return go_out
}

/*
Determines if the two convex polygons overlap on the xz-plane.

@param polya Polygon A vertices.	[(x, y, z) * @p npolya]
@param npolya The number of vertices in polygon A.
@param polyb Polygon B vertices.	[(x, y, z) * @p npolyb]
@param npolyb The number of vertices in polygon B.
@return True if the two polygons overlap.

bool dtOverlapPolyPoly2D(float const * polya, int const npolya, float const * polyb, int const npolyb)
*/
func DtOverlapPolyPoly2D(polya *float32, npolya int32, polyb *float32, npolyb int32) bool {
	var wrap_arg_polya unsafe.Pointer
	var wrap_arg_npolya C.int
	var wrap_arg_polyb unsafe.Pointer
	var wrap_arg_npolyb C.int
	wrap_arg_polya = (unsafe.Pointer)(polya)
	wrap_arg_npolya = (C.int)(npolya)
	wrap_arg_polyb = (unsafe.Pointer)(polyb)
	wrap_arg_npolyb = (C.int)(npolyb)
	wrap_out := C.nav_dtOverlapPolyPoly2D(wrap_arg_polya, wrap_arg_npolya, wrap_arg_polyb, wrap_arg_npolyb)
	go_out := bool(wrap_out)
	return go_out
}

/*
Determines if two axis-aligned bounding boxes overlap.

@param amin Minimum bounds of box A. [(x, y, z)]
@param amax Maximum bounds of box A. [(x, y, z)]
@param bmin Minimum bounds of box B. [(x, y, z)]
@param bmax Maximum bounds of box B. [(x, y, z)]
@return True if the two AABB's overlap.
@see dtOverlapBounds

bool dtOverlapQuantBounds(unsigned short const(amin)[3], unsigned short const(amax)[3], unsigned short const(bmin)[3], unsigned short const(bmax)[3])
*/
func DtOverlapQuantBounds(amin *[3]uint16, amax *[3]uint16, bmin *[3]uint16, bmax *[3]uint16) bool {
	var wrap_arg_amin unsafe.Pointer
	var wrap_arg_amax unsafe.Pointer
	var wrap_arg_bmin unsafe.Pointer
	var wrap_arg_bmax unsafe.Pointer
	wrap_arg_amin = (unsafe.Pointer)(amin)
	wrap_arg_amax = (unsafe.Pointer)(amax)
	wrap_arg_bmin = (unsafe.Pointer)(bmin)
	wrap_arg_bmax = (unsafe.Pointer)(bmax)
	wrap_out := C.nav_dtOverlapQuantBounds(wrap_arg_amin, wrap_arg_amax, wrap_arg_bmin, wrap_arg_bmax)
	go_out := bool(wrap_out)
	return go_out
}

/*
Determines if the specified point is inside the convex polygon on the xz-plane.

@param pt The point to check. [(x, y, z)]
@param verts The polygon vertices. [(x, y, z) * @p nverts]
@param nverts The number of vertices. [Limit: >= 3]
@return True if the point is inside the polygon.

bool dtPointInPolygon(float const * pt, float const * verts, int const nverts)
*/
func DtPointInPolygon(pt *float32, verts *float32, nverts int32) bool {
	var wrap_arg_pt unsafe.Pointer
	var wrap_arg_verts unsafe.Pointer
	var wrap_arg_nverts C.int
	wrap_arg_pt = (unsafe.Pointer)(pt)
	wrap_arg_verts = (unsafe.Pointer)(verts)
	wrap_arg_nverts = (C.int)(nverts)
	wrap_out := C.nav_dtPointInPolygon(wrap_arg_pt, wrap_arg_verts, wrap_arg_nverts)
	go_out := bool(wrap_out)
	return go_out
}

/*
void dtRandomPointInConvexPoly(float const * pts, int const npts, float * areas, float const s, float const t, float * out)
*/
func DtRandomPointInConvexPoly(pts *float32, npts int32, areas *float32, s float32, t float32, out *float32) {
	var wrap_arg_pts unsafe.Pointer
	var wrap_arg_npts C.int
	var wrap_arg_areas unsafe.Pointer
	var wrap_arg_s C.float
	var wrap_arg_t C.float
	var wrap_arg_out unsafe.Pointer
	wrap_arg_pts = (unsafe.Pointer)(pts)
	wrap_arg_npts = (C.int)(npts)
	wrap_arg_areas = (unsafe.Pointer)(areas)
	wrap_arg_s = (C.float)(s)
	wrap_arg_t = (C.float)(t)
	wrap_arg_out = (unsafe.Pointer)(out)
	C.nav_dtRandomPointInConvexPoly(wrap_arg_pts, wrap_arg_npts, wrap_arg_areas, wrap_arg_s, wrap_arg_t, wrap_arg_out)
}

/*
void dtSwapByte(unsigned char * a, unsigned char * b)
*/
func DtSwapByte(a *uint8, b *uint8) {
	var wrap_arg_a unsafe.Pointer
	var wrap_arg_b unsafe.Pointer
	wrap_arg_a = (unsafe.Pointer)(a)
	wrap_arg_b = (unsafe.Pointer)(b)
	C.nav_dtSwapByte(wrap_arg_a, wrap_arg_b)
}

/*
void dtSwapEndian(unsigned short * v)
*/
func DtSwapEndian(v *uint16) {
	var wrap_arg_v unsafe.Pointer
	wrap_arg_v = (unsafe.Pointer)(v)
	C.nav_dtSwapEndian(wrap_arg_v)
}

/*
void dtSwapEndian(short * v)
*/
func DtSwapEndian11(v *int16) {
	var wrap_arg_v unsafe.Pointer
	wrap_arg_v = (unsafe.Pointer)(v)
	C.nav_dtSwapEndian11(wrap_arg_v)
}

/*
void dtSwapEndian(unsigned int * v)
*/
func DtSwapEndian12(v *uint32) {
	var wrap_arg_v unsafe.Pointer
	wrap_arg_v = (unsafe.Pointer)(v)
	C.nav_dtSwapEndian12(wrap_arg_v)
}

/*
void dtSwapEndian(int * v)
*/
func DtSwapEndian13(v *int32) {
	var wrap_arg_v unsafe.Pointer
	wrap_arg_v = (unsafe.Pointer)(v)
	C.nav_dtSwapEndian13(wrap_arg_v)
}

/*
void dtSwapEndian(float * v)
*/
func DtSwapEndian14(v *float32) {
	var wrap_arg_v unsafe.Pointer
	wrap_arg_v = (unsafe.Pointer)(v)
	C.nav_dtSwapEndian14(wrap_arg_v)
}

/*
Derives the signed xz-plane area of the triangle ABC, or the relationship of line AB to point C.

@param a Vertex A. [(x, y, z)]
@param b Vertex B. [(x, y, z)]
@param c Vertex C. [(x, y, z)]
@return The signed xz-plane area of the triangle.

float dtTriArea2D(float const * a, float const * b, float const * c)
*/
func DtTriArea2D(a *float32, b *float32, c *float32) float32 {
	var wrap_arg_a unsafe.Pointer
	var wrap_arg_b unsafe.Pointer
	var wrap_arg_c unsafe.Pointer
	wrap_arg_a = (unsafe.Pointer)(a)
	wrap_arg_b = (unsafe.Pointer)(b)
	wrap_arg_c = (unsafe.Pointer)(c)
	wrap_out := C.nav_dtTriArea2D(wrap_arg_a, wrap_arg_b, wrap_arg_c)
	go_out := float32(wrap_out)
	return go_out
}

/*
Performs a vector addition. (@p v1 + @p v2)
@param dest The result vector. [(x, y, z)]
@param v1 The base vector. [(x, y, z)]
@param v2 The vector to add to @p v1. [(x, y, z)]

void dtVadd(float * dest, float const * v1, float const * v2)
*/
func DtVadd(dest *float32, v1 *float32, v2 *float32) {
	var wrap_arg_dest unsafe.Pointer
	var wrap_arg_v1 unsafe.Pointer
	var wrap_arg_v2 unsafe.Pointer
	wrap_arg_dest = (unsafe.Pointer)(dest)
	wrap_arg_v1 = (unsafe.Pointer)(v1)
	wrap_arg_v2 = (unsafe.Pointer)(v2)
	C.nav_dtVadd(wrap_arg_dest, wrap_arg_v1, wrap_arg_v2)
}

/*
Performs a vector copy.

@param dest The result. [(x, y, z)]
@param a The vector to copy. [(x, y, z)]

void dtVcopy(float * dest, float const * a)
*/
func DtVcopy(dest *float32, a *float32) {
	var wrap_arg_dest unsafe.Pointer
	var wrap_arg_a unsafe.Pointer
	wrap_arg_dest = (unsafe.Pointer)(dest)
	wrap_arg_a = (unsafe.Pointer)(a)
	C.nav_dtVcopy(wrap_arg_dest, wrap_arg_a)
}

/*
Derives the cross product of two vectors. (@p v1 x @p v2)
@param dest The cross product. [(x, y, z)]
@param v1 A Vector [(x, y, z)]
@param v2 A vector [(x, y, z)]

void dtVcross(float * dest, float const * v1, float const * v2)
*/
func DtVcross(dest *float32, v1 *float32, v2 *float32) {
	var wrap_arg_dest unsafe.Pointer
	var wrap_arg_v1 unsafe.Pointer
	var wrap_arg_v2 unsafe.Pointer
	wrap_arg_dest = (unsafe.Pointer)(dest)
	wrap_arg_v1 = (unsafe.Pointer)(v1)
	wrap_arg_v2 = (unsafe.Pointer)(v2)
	C.nav_dtVcross(wrap_arg_dest, wrap_arg_v1, wrap_arg_v2)
}

/*
Returns the distance between two points.

@param v1 A point. [(x, y, z)]
@param v2 A point. [(x, y, z)]
@return The distance between the two points.

float dtVdist(float const * v1, float const * v2)
*/
func DtVdist(v1 *float32, v2 *float32) float32 {
	var wrap_arg_v1 unsafe.Pointer
	var wrap_arg_v2 unsafe.Pointer
	wrap_arg_v1 = (unsafe.Pointer)(v1)
	wrap_arg_v2 = (unsafe.Pointer)(v2)
	wrap_out := C.nav_dtVdist(wrap_arg_v1, wrap_arg_v2)
	go_out := float32(wrap_out)
	return go_out
}

/*
Derives the distance between the specified points on the xz-plane.

@param v1 A point. [(x, y, z)]
@param v2 A point. [(x, y, z)]
@return The distance between the point on the xz-plane.
The vectors are projected onto the xz-plane, so the y-values are ignored.

float dtVdist2D(float const * v1, float const * v2)
*/
func DtVdist2D(v1 *float32, v2 *float32) float32 {
	var wrap_arg_v1 unsafe.Pointer
	var wrap_arg_v2 unsafe.Pointer
	wrap_arg_v1 = (unsafe.Pointer)(v1)
	wrap_arg_v2 = (unsafe.Pointer)(v2)
	wrap_out := C.nav_dtVdist2D(wrap_arg_v1, wrap_arg_v2)
	go_out := float32(wrap_out)
	return go_out
}

/*
Derives the square of the distance between the specified points on the xz-plane.

@param v1 A point. [(x, y, z)]
@param v2 A point. [(x, y, z)]
@return The square of the distance between the point on the xz-plane.

float dtVdist2DSqr(float const * v1, float const * v2)
*/
func DtVdist2DSqr(v1 *float32, v2 *float32) float32 {
	var wrap_arg_v1 unsafe.Pointer
	var wrap_arg_v2 unsafe.Pointer
	wrap_arg_v1 = (unsafe.Pointer)(v1)
	wrap_arg_v2 = (unsafe.Pointer)(v2)
	wrap_out := C.nav_dtVdist2DSqr(wrap_arg_v1, wrap_arg_v2)
	go_out := float32(wrap_out)
	return go_out
}

/*
Returns the square of the distance between two points.

@param v1 A point. [(x, y, z)]
@param v2 A point. [(x, y, z)]
@return The square of the distance between the two points.

float dtVdistSqr(float const * v1, float const * v2)
*/
func DtVdistSqr(v1 *float32, v2 *float32) float32 {
	var wrap_arg_v1 unsafe.Pointer
	var wrap_arg_v2 unsafe.Pointer
	wrap_arg_v1 = (unsafe.Pointer)(v1)
	wrap_arg_v2 = (unsafe.Pointer)(v2)
	wrap_out := C.nav_dtVdistSqr(wrap_arg_v1, wrap_arg_v2)
	go_out := float32(wrap_out)
	return go_out
}

/*
Derives the dot product of two vectors. (@p v1 . @p v2)
@param v1 A Vector [(x, y, z)]
@param v2 A vector [(x, y, z)]
@return The dot product.

float dtVdot(float const * v1, float const * v2)
*/
func DtVdot(v1 *float32, v2 *float32) float32 {
	var wrap_arg_v1 unsafe.Pointer
	var wrap_arg_v2 unsafe.Pointer
	wrap_arg_v1 = (unsafe.Pointer)(v1)
	wrap_arg_v2 = (unsafe.Pointer)(v2)
	wrap_out := C.nav_dtVdot(wrap_arg_v1, wrap_arg_v2)
	go_out := float32(wrap_out)
	return go_out
}

/*
Derives the dot product of two vectors on the xz-plane. (@p u . @p v)
@param u A vector [(x, y, z)]
@param v A vector [(x, y, z)]
@return The dot product on the xz-plane.
The vectors are projected onto the xz-plane, so the y-values are ignored.

float dtVdot2D(float const * u, float const * v)
*/
func DtVdot2D(u *float32, v *float32) float32 {
	var wrap_arg_u unsafe.Pointer
	var wrap_arg_v unsafe.Pointer
	wrap_arg_u = (unsafe.Pointer)(u)
	wrap_arg_v = (unsafe.Pointer)(v)
	wrap_out := C.nav_dtVdot2D(wrap_arg_u, wrap_arg_v)
	go_out := float32(wrap_out)
	return go_out
}

/*
Performs a 'sloppy' colocation check of the specified points.

@param p0 A point. [(x, y, z)]
@param p1 A point. [(x, y, z)]
@return True if the points are considered to be at the same location.
Basically, this function will return true if the specified points are
close enough to eachother to be considered colocated.

bool dtVequal(float const * p0, float const * p1)
*/
func DtVequal(p0 *float32, p1 *float32) bool {
	var wrap_arg_p0 unsafe.Pointer
	var wrap_arg_p1 unsafe.Pointer
	wrap_arg_p0 = (unsafe.Pointer)(p0)
	wrap_arg_p1 = (unsafe.Pointer)(p1)
	wrap_out := C.nav_dtVequal(wrap_arg_p0, wrap_arg_p1)
	go_out := bool(wrap_out)
	return go_out
}

/*
Checks that the specified vector's components are all finite.

@param v A point. [(x, y, z)]
@return True if all of the point's components are finite, i.e. not NaN
or any of the infinities.

bool dtVisfinite(float const * v)
*/
func DtVisfinite(v *float32) bool {
	var wrap_arg_v unsafe.Pointer
	wrap_arg_v = (unsafe.Pointer)(v)
	wrap_out := C.nav_dtVisfinite(wrap_arg_v)
	go_out := bool(wrap_out)
	return go_out
}

/*
Checks that the specified vector's 2D components are finite.

@param v A point. [(x, y, z)]

bool dtVisfinite2D(float const * v)
*/
func DtVisfinite2D(v *float32) bool {
	var wrap_arg_v unsafe.Pointer
	wrap_arg_v = (unsafe.Pointer)(v)
	wrap_out := C.nav_dtVisfinite2D(wrap_arg_v)
	go_out := bool(wrap_out)
	return go_out
}

/*
Derives the scalar length of the vector.

@param v The vector. [(x, y, z)]
@return The scalar length of the vector.

float dtVlen(float const * v)
*/
func DtVlen(v *float32) float32 {
	var wrap_arg_v unsafe.Pointer
	wrap_arg_v = (unsafe.Pointer)(v)
	wrap_out := C.nav_dtVlen(wrap_arg_v)
	go_out := float32(wrap_out)
	return go_out
}

/*
Derives the square of the scalar length of the vector. (len * len)

@param v The vector. [(x, y, z)]
@return The square of the scalar length of the vector.

float dtVlenSqr(float const * v)
*/
func DtVlenSqr(v *float32) float32 {
	var wrap_arg_v unsafe.Pointer
	wrap_arg_v = (unsafe.Pointer)(v)
	wrap_out := C.nav_dtVlenSqr(wrap_arg_v)
	go_out := float32(wrap_out)
	return go_out
}

/*
Performs a linear interpolation between two vectors. (@p v1 toward @p v2)
@param dest The result vector. [(x, y, x)]
@param v1 The starting vector.
@param v2 The destination vector.
@param t The interpolation factor. [Limits: 0
<
= value
<
= 1.0]

void dtVlerp(float * dest, float const * v1, float const * v2, float const t)
*/
func DtVlerp(dest *float32, v1 *float32, v2 *float32, t float32) {
	var wrap_arg_dest unsafe.Pointer
	var wrap_arg_v1 unsafe.Pointer
	var wrap_arg_v2 unsafe.Pointer
	var wrap_arg_t C.float
	wrap_arg_dest = (unsafe.Pointer)(dest)
	wrap_arg_v1 = (unsafe.Pointer)(v1)
	wrap_arg_v2 = (unsafe.Pointer)(v2)
	wrap_arg_t = (C.float)(t)
	C.nav_dtVlerp(wrap_arg_dest, wrap_arg_v1, wrap_arg_v2, wrap_arg_t)
}

/*
Performs a scaled vector addition. (@p v1 + (@p v2 * @p s))
@param dest The result vector. [(x, y, z)]
@param v1 The base vector. [(x, y, z)]
@param v2 The vector to scale and add to @p v1. [(x, y, z)]
@param s The amount to scale @p v2 by before adding to @p v1.

void dtVmad(float * dest, float const * v1, float const * v2, float const s)
*/
func DtVmad(dest *float32, v1 *float32, v2 *float32, s float32) {
	var wrap_arg_dest unsafe.Pointer
	var wrap_arg_v1 unsafe.Pointer
	var wrap_arg_v2 unsafe.Pointer
	var wrap_arg_s C.float
	wrap_arg_dest = (unsafe.Pointer)(dest)
	wrap_arg_v1 = (unsafe.Pointer)(v1)
	wrap_arg_v2 = (unsafe.Pointer)(v2)
	wrap_arg_s = (C.float)(s)
	C.nav_dtVmad(wrap_arg_dest, wrap_arg_v1, wrap_arg_v2, wrap_arg_s)
}

/*
Selects the maximum value of each element from the specified vectors.

@param mx A vector.  (Will be updated with the result.) [(x, y, z)]
@param v A vector. [(x, y, z)]

void dtVmax(float * mx, float const * v)
*/
func DtVmax(mx *float32, v *float32) {
	var wrap_arg_mx unsafe.Pointer
	var wrap_arg_v unsafe.Pointer
	wrap_arg_mx = (unsafe.Pointer)(mx)
	wrap_arg_v = (unsafe.Pointer)(v)
	C.nav_dtVmax(wrap_arg_mx, wrap_arg_v)
}

/*
Selects the minimum value of each element from the specified vectors.

@param mn A vector.  (Will be updated with the result.) [(x, y, z)]
@param v A vector. [(x, y, z)]

void dtVmin(float * mn, float const * v)
*/
func DtVmin(mn *float32, v *float32) {
	var wrap_arg_mn unsafe.Pointer
	var wrap_arg_v unsafe.Pointer
	wrap_arg_mn = (unsafe.Pointer)(mn)
	wrap_arg_v = (unsafe.Pointer)(v)
	C.nav_dtVmin(wrap_arg_mn, wrap_arg_v)
}

/*
Normalizes the vector.

@param v The vector to normalize. [(x, y, z)]

void dtVnormalize(float * v)
*/
func DtVnormalize(v *float32) {
	var wrap_arg_v unsafe.Pointer
	wrap_arg_v = (unsafe.Pointer)(v)
	C.nav_dtVnormalize(wrap_arg_v)
}

/*
Derives the xz-plane 2D perp product of the two vectors. (uz*vx - ux*vz)

@param u The LHV vector [(x, y, z)]
@param v The RHV vector [(x, y, z)]
@return The perp dot product on the xz-plane.
The vectors are projected onto the xz-plane, so the y-values are ignored.

float dtVperp2D(float const * u, float const * v)
*/
func DtVperp2D(u *float32, v *float32) float32 {
	var wrap_arg_u unsafe.Pointer
	var wrap_arg_v unsafe.Pointer
	wrap_arg_u = (unsafe.Pointer)(u)
	wrap_arg_v = (unsafe.Pointer)(v)
	wrap_out := C.nav_dtVperp2D(wrap_arg_u, wrap_arg_v)
	go_out := float32(wrap_out)
	return go_out
}

/*
Scales the vector by the specified value. (@p v * @p t)
@param dest The result vector. [(x, y, z)]
@param v The vector to scale. [(x, y, z)]
@param t The scaling factor.

void dtVscale(float * dest, float const * v, float const t)
*/
func DtVscale(dest *float32, v *float32, t float32) {
	var wrap_arg_dest unsafe.Pointer
	var wrap_arg_v unsafe.Pointer
	var wrap_arg_t C.float
	wrap_arg_dest = (unsafe.Pointer)(dest)
	wrap_arg_v = (unsafe.Pointer)(v)
	wrap_arg_t = (C.float)(t)
	C.nav_dtVscale(wrap_arg_dest, wrap_arg_v, wrap_arg_t)
}

/*
Sets the vector elements to the specified values.

@param dest The result vector. [(x, y, z)]
@param x The x-value of the vector.
@param y The y-value of the vector.
@param z The z-value of the vector.

void dtVset(float * dest, float const x, float const y, float const z)
*/
func DtVset(dest *float32, x float32, y float32, z float32) {
	var wrap_arg_dest unsafe.Pointer
	var wrap_arg_x C.float
	var wrap_arg_y C.float
	var wrap_arg_z C.float
	wrap_arg_dest = (unsafe.Pointer)(dest)
	wrap_arg_x = (C.float)(x)
	wrap_arg_y = (C.float)(y)
	wrap_arg_z = (C.float)(z)
	C.nav_dtVset(wrap_arg_dest, wrap_arg_x, wrap_arg_y, wrap_arg_z)
}

/*
Performs a vector subtraction. (@p v1 - @p v2)
@param dest The result vector. [(x, y, z)]
@param v1 The base vector. [(x, y, z)]
@param v2 The vector to subtract from @p v1. [(x, y, z)]

void dtVsub(float * dest, float const * v1, float const * v2)
*/
func DtVsub(dest *float32, v1 *float32, v2 *float32) {
	var wrap_arg_dest unsafe.Pointer
	var wrap_arg_v1 unsafe.Pointer
	var wrap_arg_v2 unsafe.Pointer
	wrap_arg_dest = (unsafe.Pointer)(dest)
	wrap_arg_v1 = (unsafe.Pointer)(v1)
	wrap_arg_v2 = (unsafe.Pointer)(v2)
	C.nav_dtVsub(wrap_arg_dest, wrap_arg_v1, wrap_arg_v2)
}
